import { request } from '@/utils/request';
import { WS_CONFIG } from '@/config/websocket';

/**
 * 检查是否有未结束的会话
 */
export const checkSession = () => {
  return request.get('/api/chat/session/check');
};

/**
 * 创建新会话
 */
export const createSession = (sessionType = 'AI') => {
  return request.post('/api/chat/session/create', null, {
    params: { sessionType }
  });
};

/**
 * 加载历史消息
 * @param {string} sessionId - 会话ID
 * @param {number} page - 页码
 * @param {number} size - 每页大小
 */
export const loadMessages = async (sessionId, page = 1, size = 20) => {
  console.log('加载历史消息, sessionId:', sessionId, 'page:', page, 'size:', size);
  
  const userInfo = uni.getStorageSync('userInfo');
  console.log('当前用户信息:', userInfo);
  
  if (!userInfo || (!userInfo.id && !userInfo.userId)) {
    console.error('用户信息不完整:', userInfo);
    throw new Error('未找到用户信息，请重新登录');
  }
  
  const userId = userInfo.userId || userInfo.id;

  try {
    const response = await request.get('/api/chat/history', {
      params: {
        userId: userId,
      sessionId: sessionId,
      page: page,
      size: size
      }
    });

    console.log('历史消息响应:', response);

    if (!response.success) {
      // 如果是500错误且可能是大模型连接问题，返回空数据而不是抛出错误
      if (response.code === 500) {
        console.warn('获取历史消息时遇到服务器错误，可能是大模型连接问题，尝试使用本地缓存');
        return { success: true, data: { records: [] } };
      }
      throw new Error(response.message || '加载消息失败');
    }

    return response;
  } catch (error) {
    console.error('加载消息失败:', error);
    
    // 如果是大模型连接错误，提供更友好的错误信息
    if (error.message && (
      error.message.includes('Failed to connect to localhost') ||
      error.message.includes('Connection refused') ||
      error.message.includes('系统繁忙')
    )) {
      throw new Error('暂时无法连接到AI服务，但您仍可以与客服交流');
    }
    
    throw error;
  }
};

/**
 * 加载新消息
 * @param {string} sessionId - 会话ID
 * @param {string} [afterMessageId] - 消息ID，获取此消息之后的消息
 */
export const loadNewMessages = (sessionId, lastMessageId) => {
  console.log('加载新消息, sessionId:', sessionId, 'lastMessageId:', lastMessageId);
  
  // 从缓存中获取用户信息
  const userInfo = uni.getStorageSync('userInfo');
  
  if (!userInfo || (!userInfo.id && !userInfo.userId)) {
    console.error('加载新消息失败: 未找到用户ID');
    return Promise.reject(new Error('未登录或用户信息不完整'));
  }
  
  // 使用userId字段，如果不存在则尝试使用id字段
  const userId = userInfo.userId || userInfo.id;
  
  // 构建参数对象
  const params = {
    sessionId,
    lastMessageId,
    userId
  };
  
  console.log('加载新消息，参数:', params);
  
  // 使用后端实际提供的API路径
  return request.get('/api/chat/history/new', { params });
};

let ws = null;
let reconnectAttempts = 0;
let heartbeatTimer = null;
let reconnectTimer = null;

/**
 * 建立WebSocket连接
 * @param {number} userId - 用户ID
 */
export const connectWebSocket = (userId) => {
    return new Promise((resolve, reject) => {
        try {
            // 如果已有连接，先关闭
            if (ws) {
                ws.close();
            }

            // 清除之前的定时器
            if (heartbeatTimer) {
                clearInterval(heartbeatTimer);
            }
            if (reconnectTimer) {
                clearTimeout(reconnectTimer);
            }

            // 构建WebSocket URL，添加token
            const token = uni.getStorageSync('token');
            const wsUrl = `${WS_CONFIG.WS_URL}/${userId}?token=${token}`;

            ws = uni.connectSocket({
                url: wsUrl,
                success: () => {
                    console.log('WebSocket连接成功');
                    uni.setStorageSync('websocket', ws);
                    startHeartbeat();
                    reconnectAttempts = 0;
                    resolve(ws);
                },
                fail: (err) => {
                    console.error('WebSocket连接失败:', err);
                    handleReconnect();
                    reject(err);
                }
            });

            ws.onOpen(() => {
                console.log('WebSocket连接已打开');
                reconnectAttempts = 0;
                startHeartbeat();
            });

            ws.onError((error) => {
                console.error('WebSocket错误:', error);
                handleReconnect();
            });

            ws.onClose((res) => {
                console.log('WebSocket连接已关闭:', res);
                stopHeartbeat();
                if (res.code !== 1000) { // 非正常关闭
                    handleReconnect();
                }
                uni.removeStorageSync('websocket');
            });

            ws.onMessage((message) => {
                console.log('收到WebSocket消息:', message);
                try {
                    const data = JSON.parse(message.data);
                    if (data.type === 'PONG') {
                        // 处理心跳响应
                        console.log('收到PONG响应:', data);
                        return;
                    }
                    handleWebSocketMessage(data);
                } catch (error) {
                    console.error('解析WebSocket消息失败:', error);
                }
            });
        } catch (error) {
            console.error('建立WebSocket连接异常:', error);
            handleReconnect();
            reject(error);
        }
    });
};

/**
 * 处理重连
 */
const handleReconnect = () => {
    if (reconnectAttempts >= WS_CONFIG.RECONNECT.MAX_ATTEMPTS) {
        console.error('WebSocket重连次数超过最大限制');
        uni.showToast({
            title: '连接服务器失败，请刷新页面重试',
            icon: 'none',
            duration: 2000
        });
        return;
    }

    reconnectAttempts++;
    console.log(`尝试重连 (${reconnectAttempts}/${WS_CONFIG.RECONNECT.MAX_ATTEMPTS})`);

    reconnectTimer = setTimeout(() => {
        const userInfo = uni.getStorageSync('userInfo');
        if (userInfo && userInfo.id) {
            connectWebSocket(userInfo.id);
        }
    }, WS_CONFIG.RECONNECT.INTERVAL);
};

/**
 * 开始心跳检测
 */
const startHeartbeat = () => {
    stopHeartbeat();
    heartbeatTimer = setInterval(() => {
        if (ws && ws.readyState === 1) {
            sendWebSocketMessage({
                type: 'PING',
                timestamp: new Date().toISOString(),
                status: 'SENT',
                sessionId: '' // 添加空的sessionId字段，避免后端NPE
            });
        }
    }, WS_CONFIG.HEARTBEAT.INTERVAL);
};

/**
 * 停止心跳检测
 */
const stopHeartbeat = () => {
    if (heartbeatTimer) {
        clearInterval(heartbeatTimer);
        heartbeatTimer = null;
    }
};

/**
 * 处理WebSocket消息
 */
const handleWebSocketMessage = (message) => {
  try {
    console.log('处理WebSocket消息:', message);
    
    // 如果消息没有类型，无法处理
    if (!message.type) {
      console.warn('收到无类型的WebSocket消息:', message);
      return;
    }
    
    switch (message.type) {
      case 'CHAT':
        // 处理聊天消息
        console.log('收到聊天消息:', message);
        uni.$emit('new-chat-message', message);
        break;
        
      case 'SYSTEM':
        // 处理系统消息
        console.log('收到系统消息:', message);
        uni.$emit('system-message', message);
        break;
        
      case 'TRANSFER':
        // 处理转接消息
        console.log('收到转接消息:', message);
        uni.$emit('transfer-message', message);
        break;
        
      case 'SESSION_ACCEPTED':
        // 处理会话接受消息
        console.log('收到会话接受消息:', message);
        uni.$emit('session-accepted', message);
        break;
        
      case 'SESSION_REJECTED':
        // 处理会话拒绝消息
        console.log('收到会话拒绝消息:', message);
        uni.$emit('session-rejected', message);
        break;
        
      case 'SESSION_ENDED':
        // 处理会话结束消息
        console.log('收到会话结束消息:', message);
        uni.$emit('session-ended', message);
        break;
        
      case 'SESSION_ASSIGNED':
        // 处理会话分配消息
        console.log('收到会话分配消息:', message);
        uni.$emit('session-assigned', message);
        break;
        
      case 'ERROR':
        // 处理错误消息
        console.error('收到错误消息:', message);
        uni.$emit('error-message', message);
        
        // 显示错误提示
        uni.showToast({
          title: message.content || '发生错误',
          icon: 'none',
          duration: 3000
        });
        
        // 如果是消息处理失败的错误，尝试通过HTTP API重发
        if (message.content && message.content.includes('消息处理失败') && message.sessionId) {
          console.log('尝试通过HTTP API重发消息...');
          
          // 从本地存储中获取最后一条发送失败的消息
          const lastMessage = uni.getStorageSync('last_message_' + message.sessionId);
          if (lastMessage && lastMessage.content) {
            // 使用HTTP API重发
            sendSessionMessage(message.sessionId, lastMessage.content)
              .then(res => {
                console.log('通过HTTP API重发消息成功:', res);
              })
              .catch(err => {
                console.error('通过HTTP API重发消息失败:', err);
              });
          }
        }
        break;
        
      default:
        console.warn('未知的消息类型:', message.type, message);
        
        // 尝试解析消息数据
        if (typeof message.data === 'string') {
          try {
            const parsedData = JSON.parse(message.data);
            console.log('解析消息数据:', parsedData);
            
            // 根据解析后的数据类型处理
            if (parsedData.type) {
              handleWebSocketMessage(parsedData);
            }
          } catch (error) {
            console.error('解析消息数据失败:', error);
          }
        }
        break;
    }
  } catch (error) {
    console.error('处理WebSocket消息出错:', error);
  }
};

/**
 * 发送WebSocket消息
 * @param {Object} message - 消息对象
 */
export const sendWebSocketMessage = async (message) => {
    if (!ws || ws.readyState !== 1) {
        throw new Error('WebSocket未连接');
    }

    return new Promise((resolve, reject) => {
        try {
            ws.send({
                data: JSON.stringify(message),
                success: () => {
                    console.log('WebSocket消息发送成功');
                    resolve();
                },
                fail: (error) => {
                    console.error('WebSocket消息发送失败:', error);
                    reject(error);
                }
            });
        } catch (error) {
            console.error('WebSocket消息发送异常:', error);
            reject(error);
        }
    });
};

/**
 * 发送消息
 * @param {string|object} message - 消息内容或消息对象
 * @param {string} sessionId - 会话ID
 * @param {string} modelName - 模型名称
 */
export const sendMessage = async (message, sessionId, modelName = 'llama2') => {
  console.log('发送消息, message:', message, 'sessionId:', sessionId);

  // 处理对象形式的消息参数
  if (typeof message === 'object' && message !== null) {
    // 如果message是一个对象，则从对象中提取需要的值
    sessionId = message.sessionId || sessionId;
    const content = message.content || '';
    const messageType = message.messageType || 'TEXT';
    
    console.log('从对象中提取的参数 - sessionId:', sessionId, 'content:', content, 'messageType:', messageType);

  const userInfo = uni.getStorageSync('userInfo');
    // 修改检查逻辑，使用userId而不是id
    if (!userInfo || (!userInfo.id && !userInfo.userId)) {
    throw new Error('未找到用户信息，请重新登录');
  }
    
    // 使用userId字段，如果不存在则尝试使用id字段
    const userId = userInfo.userId || userInfo.id;

  try {
    const response = await request.post('/api/chat/send', null, {
      params: {
          userId: userId,
          message: content,
          sessionId: sessionId,
          messageType: messageType,
          modelName: modelName
        }
      });

      if (!response.success) {
        // 处理AI模型错误，但不影响基本聊天功能
        if (response.message && response.message.includes('Failed to communicate with Ollama API')) {
          console.warn('AI模型服务暂时不可用，但消息已发送');
          return {
            success: true,
            message: '消息已发送，但AI模型暂时不可用',
            data: {
              content: content,
              sessionId: sessionId,
              messageType: messageType,
              senderId: userId,
              timestamp: new Date().toISOString()
            }
          };
        }
        throw new Error(response.message || '发送消息失败');
      }

      return response;
    } catch (error) {
      console.error('发送消息失败:', error);
      
      // 如果是Ollama API错误，提供更友好的错误信息并尝试通过WebSocket继续聊天功能
      if (error.message && error.message.includes('Failed to communicate with Ollama API')) {
        console.warn('AI模型服务暂时不可用，尝试通过WebSocket发送消息');
        
        // 如果WebSocket连接存在，尝试通过WebSocket发送
        const ws = uni.getStorageSync('websocket');
        if (ws && ws.readyState === 1) {
          try {
            console.log('尝试通过WebSocket发送消息');
            await sendWebSocketMessage({
              type: 'CHAT',
              sessionId: sessionId,
              senderId: userId,
              content: content,
              messageType: messageType,
              timestamp: new Date().toISOString()
            });
            return { 
              success: true, 
              message: '通过WebSocket发送成功',
              data: {
                content: content,
                sessionId: sessionId,
                messageType: messageType,
                senderId: userId,
                timestamp: new Date().toISOString()
              }
            };
          } catch (wsError) {
            console.error('WebSocket发送也失败:', wsError);
          }
        }
        
        return { 
          success: true, 
          message: '消息已记录，但AI模型暂时不可用',
          data: {
            content: content,
            sessionId: sessionId,
            messageType: messageType,
            senderId: userId,
            timestamp: new Date().toISOString()
          }
        };
      }
      
      throw error;
    }
  } else {
    // 原有的字符串处理逻辑
    const userInfo = uni.getStorageSync('userInfo');
    // 修改检查逻辑，使用userId而不是id
    if (!userInfo || (!userInfo.id && !userInfo.userId)) {
      throw new Error('未找到用户信息，请重新登录');
    }
    
    // 使用userId字段，如果不存在则尝试使用id字段
    const userId = userInfo.userId || userInfo.id;

    try {
      const response = await request.post('/api/chat/send', null, {
        params: {
          userId: userId,
        message: message,
        sessionId: sessionId,
        modelName: modelName
      }
    });

    if (!response.success) {
      // 处理AI模型错误，但不影响基本聊天功能
      if (response.message && response.message.includes('Failed to communicate with Ollama API')) {
        console.warn('AI模型服务暂时不可用，但消息已发送');
        return {
          success: true,
          message: '消息已发送，但AI模型暂时不可用',
          data: {
            content: message,
            sessionId: sessionId,
            senderId: userId,
            timestamp: new Date().toISOString()
          }
        };
      }
      throw new Error(response.message || '发送消息失败');
    }

    return response;
  } catch (error) {
    console.error('发送消息失败:', error);
    
    // 如果是Ollama API错误，提供更友好的错误信息并尝试通过WebSocket继续聊天功能
    if (error.message && error.message.includes('Failed to communicate with Ollama API')) {
      console.warn('AI模型服务暂时不可用，尝试通过WebSocket发送消息');
    
    // 如果WebSocket连接存在，尝试通过WebSocket发送
    const ws = uni.getStorageSync('websocket');
    if (ws && ws.readyState === 1) {
      try {
          console.log('尝试通过WebSocket发送消息');
        await sendWebSocketMessage({
          type: 'CHAT',
          sessionId: sessionId,
            senderId: userId,
          content: message,
          timestamp: new Date().toISOString()
        });
          return { 
            success: true, 
            message: '通过WebSocket发送成功',
            data: {
              content: message,
              sessionId: sessionId,
              senderId: userId,
              timestamp: new Date().toISOString()
            }
          };
      } catch (wsError) {
        console.error('WebSocket发送也失败:', wsError);
        }
      }
      
      return { 
        success: true, 
        message: '消息已记录，但AI模型暂时不可用',
        data: {
          content: message,
          sessionId: sessionId,
          senderId: userId,
          timestamp: new Date().toISOString()
      }
      };
    }
    
    throw error;
    }
  }
};

/**
 * 获取客服统计数据
 */
export function getServiceStats() {
  return request.get('/api/chat/stats');
}

/**
 * 获取客服当前活跃会话列表
 */
export function getServiceSessions() {
  // 从缓存中获取用户信息
  const userInfo = uni.getStorageSync('userInfo');
  
  if (!userInfo || (!userInfo.id && !userInfo.userId)) {
    console.error('获取客服会话列表失败: 未找到用户ID');
    return Promise.reject(new Error('未登录或用户信息不完整'));
  }
  
  // 使用userId字段，如果不存在则尝试使用id字段
  const userId = userInfo.userId || userInfo.id;
  
  console.log('获取客服会话列表，用户ID:', userId);
  
  return request.get('/api/chat/sessions', {
    params: { userId }
  });
}

/**
 * 获取历史消息
 * @param {Object} params - 查询参数
 */
export function getHistory(params) {
  // 从缓存中获取用户信息
  const userInfo = uni.getStorageSync('userInfo');
  
  if (!userInfo || (!userInfo.id && !userInfo.userId)) {
    console.error('获取历史消息失败: 未找到用户ID');
    return Promise.reject(new Error('未登录或用户信息不完整'));
  }
  
  // 使用userId字段，如果不存在则尝试使用id字段
  const userId = userInfo.userId || userInfo.id;
  
  // 创建新的参数对象，包含userId
  const newParams = { 
    ...params,
    userId: userId 
  };
  
  console.log('获取历史消息，参数:', newParams);
  
  return request.get('/api/chat/history', { params: newParams });
}

/**
 * 获取会话列表
 */
export const getSessions = (current = 1, pageSize = 10) => {
  // 从缓存中获取用户信息
  const userInfo = uni.getStorageSync('userInfo');
  
  if (!userInfo || (!userInfo.id && !userInfo.userId)) {
    console.error('获取会话列表失败: 未找到用户ID');
    return Promise.reject(new Error('未登录或用户信息不完整'));
  }
  
  // 使用userId字段，如果不存在则尝试使用id字段
  const userId = userInfo.userId || userInfo.id;
  
  console.log('获取会话列表，用户ID:', userId, '页码:', current, '每页大小:', pageSize);
  
  return request.get('/api/chat/sessions', {
    params: { 
      userId,
      current, 
      pageSize 
    }
  });
};

/**
 * 创建新会话
 * @param {Object} data - 会话数据
 */
export function createConversation(data) {
  return request.post('/api/chat/conversation', data);
}

/**
 * 删除会话
 * @param {string} conversationId - 会话ID
 */
export function deleteConversation(conversationId) {
  return request.delete(`/api/chat/conversation/${conversationId}`);
}

/**
 * 评价会话
 */
export const evaluateSession = (sessionId, score, evaluation) => {
  return request.post(`/api/chat/session/${sessionId}/evaluate`, null, {
    params: { score, evaluation }
  });
};

/**
 * 发起会话转接
 * @param {string} sessionId - 会话ID
 * @param {number} fromServiceId - 来源客服ID
 * @param {number} toServiceId - 目标客服ID
 * @param {string} reason - 转接原因
 */
export function initiateTransfer(sessionId, fromServiceId, toServiceId, reason) {
  return request.post('/api/chat/transfer/initiate', {
    sessionId,
    fromServiceId,
    toServiceId,
    reason
  });
}

/**
 * 接受会话转接
 * @param {number} transferId - 转接ID
 * @param {number} serviceId - 客服ID
 */
export function acceptTransfer(transferId, serviceId) {
  return request.post('/api/chat/transfer/accept', {
    transferId,
    serviceId
  });
}

/**
 * 拒绝转接会话
 * @param {number} transferId - 转接ID
 * @param {number} serviceId - 客服ID
 * @param {string} rejectReason - 拒绝原因
 */
export function rejectTransfer(transferId, serviceId, rejectReason) {
  return request.post('/api/chat/transfer/reject', {
    transferId,
    serviceId,
    rejectReason
  });
}

/**
 * 获取待处理的转接请求
 * @param {number} serviceId - 客服ID
 */
export function getPendingTransfers(serviceId) {
  return request.get('/api/chat/transfer/pending', {
    params: { serviceId }
  });
}

/**
 * 获取会话的转接历史
 * @param {string} sessionId - 会话ID
 */
export function getTransferHistory(sessionId) {
  return request.get('/api/chat/transfer/history', {
    params: { sessionId }
  });
}

/**
 * 取消转接请求
 * @param {number} transferId - 转接ID
 * @param {number} serviceId - 客服ID
 */
export function cancelTransfer(transferId, serviceId) {
  return request.post('/api/chat/transfer/cancel', {
    transferId,
    serviceId
  });
}

/**
 * 获取活跃会话列表
 */
export const getActiveSessions = () => {
  // 从缓存中获取用户信息
  const userInfo = uni.getStorageSync('userInfo');
  
  // 尝试获取客服ID，优先使用serviceId，然后是userId，最后是id
  let serviceId;
  if (userInfo?.serviceInfo?.id) {
    // 如果有嵌套的serviceInfo，优先使用
    serviceId = userInfo.serviceInfo.id;
  } else {
    // 否则尝试使用userId或id
    serviceId = userInfo?.userId || userInfo?.id;
  }
  
  if(!serviceId) {
    console.error('获取活跃会话失败: 未找到客服ID');
    return Promise.reject(new Error('未登录或客服信息不完整'));
  }
  
  console.log('获取活跃会话，客服ID:', serviceId);
  
  // 修正API调用，确保参数正确传递
  return request.get('/api/chat/active', {
    params: { serviceId: serviceId }
  }).catch(error => {
    console.error('获取活跃会话失败:', error);
    throw new Error(error.message || '获取活跃会话失败，请稍后重试');
  });
};

/**
 * 获取历史会话列表
 * @param {Object} params - 查询参数
 */
export function getHistorySessions(params) {
  return request.get('/api/chat/sessions/history', { params });
}

/**
 * 获取会话详情
 */
export const getSessionDetail = (sessionId) => {
  // 从缓存中获取用户信息
  const userInfo = uni.getStorageSync('userInfo');
  
  if (!userInfo || (!userInfo.id && !userInfo.userId)) {
    console.error('获取会话详情失败: 未找到用户ID');
    return Promise.reject(new Error('未登录或用户信息不完整'));
  }
  
  // 使用userId字段，如果不存在则尝试使用id字段
  const userId = userInfo.userId || userInfo.id;
  
  console.log('获取会话详情，会话ID:', sessionId, '用户ID:', userId);
  
  return request.get(`/api/chat/session/${sessionId}`, {
    params: { userId }
  });
};

/**
 * 获取会话消息
 */
export const getSessionMessages = (sessionId) => {
  // 从缓存中获取用户信息
  const userInfo = uni.getStorageSync('userInfo');
  
  if (!userInfo || (!userInfo.id && !userInfo.userId)) {
    console.error('获取会话消息失败: 未找到用户ID');
    return Promise.reject(new Error('未登录或用户信息不完整'));
  }
  
  // 使用userId字段，如果不存在则尝试使用id字段
  const userId = userInfo.userId || userInfo.id;
  
  console.log('获取会话消息，会话ID:', sessionId, '用户ID:', userId);
  
  return request.get(`/api/chat/session/${sessionId}/messages`, {
    params: { userId }
  })
  .then(response => {
    if (!response.success && response.code === 500) {
      console.warn('获取会话消息时遇到服务器错误，可能是大模型连接问题，尝试使用本地缓存');
      // 如果是大模型连接错误，返回空数组而不是抛出错误
      return { success: true, data: [] };
    }
    return response;
  })
  .catch(error => {
    console.error('获取会话消息出错:', error);
    // 如果是大模型连接错误，提供更友好的错误信息
    if (error.message && error.message.includes('Failed to connect to localhost')) {
      return Promise.reject(new Error('暂时无法连接到AI服务，但您仍可以与客服交流'));
    }
    return Promise.reject(error);
  });
};

/**
 * 结束会话
 */
export const endSession = (sessionId, endReason) => {
  return request.post(`/api/chat/session/${sessionId}/end`, null, {
    params: { endReason }
  });
};

/**
 * 搜索会话
 * @param {Object} params - 搜索参数
 */
export function searchSessions(params) {
  return request.get('/api/chat/sessions/search', { params });
}

/**
 * 获取会话统计数据
 * @param {string} date - 日期，格式：yyyy-MM-dd
 */
export function getSessionsStats(date) {
  return request.get('/api/chat/sessions/stats', { 
    params: { date }
  });
}

/**
 * 接受会话
 * @param {string} sessionId - 会话ID
 */
export function acceptSession(sessionId) {
  if (!sessionId) {
    console.error('接受会话失败: 会话ID为空');
    return Promise.reject(new Error('会话ID不能为空'));
  }
  
  // 添加重试逻辑
  const maxRetries = 3;
  let retryCount = 0;
  
  const attemptAccept = () => {
    retryCount++;
    console.log(`尝试接受会话 (${retryCount}/${maxRetries})...`);
    
    // 使用acceptSessionAssignment函数，因为后端没有提供单独的acceptSession接口
    return acceptSessionAssignment(sessionId)
      .catch(error => {
        console.error(`接受会话请求失败 (尝试 ${retryCount}/${maxRetries}):`, error);
        
        if (retryCount < maxRetries) {
          console.log(`接受会话失败，等待重试 (${retryCount}/${maxRetries})...`);
          // 等待1秒后重试
          return new Promise(resolve => {
            setTimeout(() => resolve(attemptAccept()), 1000);
          });
        }
        
        throw new Error(error.message || '接受会话失败，请稍后重试');
      });
  };
  
  return attemptAccept();
}

/**
 * 拒绝会话
 * @param {string} sessionId - 会话ID
 * @param {string} reason - 拒绝原因
 */
export function rejectSession(sessionId, reason) {
  if (!sessionId) {
    console.error('拒绝会话失败: 会话ID为空');
    return Promise.reject(new Error('会话ID不能为空'));
  }
  
  // 确保有拒绝原因
  const rejectReason = reason || '客服当前无法接待';
  
  // 添加重试逻辑
  const maxRetries = 3;
  let retryCount = 0;
  
  const attemptReject = () => {
    retryCount++;
    console.log(`尝试拒绝会话 (${retryCount}/${maxRetries})...`);
    
    // 使用与acceptSessionAssignment相同的请求方式，确保正确传递reason参数
    return request.post(`/api/chat/session/${sessionId}/reject-assignment`, {
      reason: rejectReason
    }, {
      headers: {
        'Content-Type': 'application/json'
      }
    })
    .then(response => {
      // 检查响应是否成功
      if (!response || response.success === false) {
        console.error(`拒绝会话响应错误: ${JSON.stringify(response)}`);
        throw new Error(response?.message || '拒绝会话失败');
      }
      
      console.log(`拒绝会话成功: ${JSON.stringify(response)}`);
      return response;
    })
    .catch(error => {
      console.error(`拒绝会话请求失败 (尝试 ${retryCount}/${maxRetries}):`, error);
      
      if (retryCount < maxRetries) {
        console.log(`拒绝会话失败，等待重试 (${retryCount}/${maxRetries})...`);
        // 等待1秒后重试
        return new Promise(resolve => {
          setTimeout(() => resolve(attemptReject()), 1000);
        });
      }
      
      // 提供更详细的错误信息
      throw new Error(error.message || '拒绝会话失败，请稍后重试');
    });
  };
  
  return attemptReject();
}

/**
 * 转接会话
 * @param {string} sessionId - 会话ID
 * @param {number} targetServiceId - 目标客服ID
 * @param {string} reason - 转接原因
 */
export const transferSession = async (sessionId, targetServiceId, reason) => {
  if (!sessionId || !targetServiceId) {
    throw new Error('会话ID和目标客服ID不能为空');
  }

  try {
    const response = await request.post('/api/chat/session/assign', {
      serviceId: targetServiceId,
      reason: reason || '客服转接'
    });

    if (!response.success) {
      throw new Error(response.message || '转接失败');
    }

    // 转接成功后，通过WebSocket通知相关方
    const ws = uni.getStorageSync('websocket');
    if (ws && ws.readyState === 1) {
      await sendWebSocketMessage({
        type: 'TRANSFER',
        sessionId: sessionId,
        targetServiceId: targetServiceId,
        reason: reason,
        timestamp: new Date().toISOString()
      });
    }

    return response;
  } catch (error) {
    console.error('转接会话失败:', error);
    throw error;
  }
};

/**
 * 发送会话消息
 * @param {string} sessionId - 会话ID
 * @param {string} content - 消息内容
 */
export const sendSessionMessage = (sessionId, content) => {
  return request.post(`/api/chat/session/${sessionId}/message`, { content });
};

/**
 * 获取待分配会话列表
 */
export const getPendingSessions = () => {
  // 从缓存中获取用户信息
  const userInfo = uni.getStorageSync('userInfo');
  
  // 尝试获取客服ID，优先使用serviceId，然后是userId，最后是id
  let serviceId;
  if (userInfo?.serviceInfo?.id) {
    // 如果有嵌套的serviceInfo，优先使用
    serviceId = userInfo.serviceInfo.id;
  } else {
    // 否则尝试使用userId或id
    serviceId = userInfo?.userId || userInfo?.id;
  }
  
  if(!serviceId) {
    console.error('获取待分配会话失败: 未找到客服ID');
    return Promise.reject(new Error('未登录或客服信息不完整'));
  }
  
  console.log('获取待分配会话，客服ID:', serviceId);
  
  // 修正API调用，确保参数正确传递
  return request.get('/api/chat/pending', {
    params: { serviceId: serviceId }
  }).catch(error => {
    console.error('获取待分配会话失败:', error);
    throw new Error(error.message || '获取待分配会话失败，请稍后重试');
  });
};

/**
 * 接受会话分配
 * @param {string} sessionId - 会话ID
 * @returns {Promise}
 */
export const acceptSessionAssignment = (sessionId) => {
  if (!sessionId) {
    console.error('接受会话失败: 会话ID为空');
    return Promise.reject(new Error('会话ID不能为空'));
  }
  
  console.log('接受会话分配，会话ID:', sessionId);
  
  // 获取当前客服ID
  const userInfo = uni.getStorageSync('userInfo');
  let serviceId;
  if (userInfo?.serviceInfo?.id) {
    serviceId = userInfo.serviceInfo.id;
  } else {
    serviceId = userInfo?.userId || userInfo?.id;
  }
  
  if (!serviceId) {
    console.error('接受会话失败: 未找到客服ID');
    return Promise.reject(new Error('客服信息不完整，请重新登录'));
  }
  
  console.log('当前客服ID:', serviceId);
  
  // 添加重试逻辑
  const maxRetries = 3;
  let retryCount = 0;
  
  const attemptAccept = () => {
    retryCount++;
    console.log(`尝试接受会话 (${retryCount}/${maxRetries})...`);
    
    // 发送请求时确保serviceId作为请求体参数
    return request.post(`/api/chat/session/${sessionId}/accept-assignment`, {
      serviceId: serviceId
    })
    .then(response => {
      // 检查响应是否成功
      if (!response || response.success === false) {
        console.error(`接受会话响应错误: ${JSON.stringify(response)}`);
        throw new Error(response?.message || '接受会话失败');
      }
      
      console.log(`接受会话成功: ${JSON.stringify(response)}`);
      return response;
    })
    .catch(error => {
      console.error(`接受会话请求失败 (尝试 ${retryCount}/${maxRetries}):`, error);
      
      if (retryCount < maxRetries) {
        console.log(`接受会话失败，等待重试 (${retryCount}/${maxRetries})...`);
        // 等待1秒后重试
        return new Promise(resolve => {
          setTimeout(() => resolve(attemptAccept()), 1000);
        });
      }
      
      // 提供更详细的错误信息
      throw new Error(error.message || '接受会话失败，请稍后重试');
    });
  };
  
  return attemptAccept();
};

/**
 * 拒绝会话分配
 * @param {string} sessionId - 会话ID
 * @param {string} reason - 拒绝原因
 * @returns {Promise}
 */
export const rejectSessionAssignment = (sessionId, reason) => {
  if (!sessionId) {
    console.error('拒绝会话失败: 会话ID为空');
    return Promise.reject(new Error('会话ID不能为空'));
  }
  
  // 确保有拒绝原因
  const rejectReason = reason || '客服当前无法接待';
  
  console.log('拒绝会话分配，会话ID:', sessionId, '原因:', rejectReason);
  
  // 获取当前客服ID
  const userInfo = uni.getStorageSync('userInfo');
  let serviceId;
  if (userInfo?.serviceInfo?.id) {
    serviceId = userInfo.serviceInfo.id;
  } else {
    serviceId = userInfo?.userId || userInfo?.id;
  }
  
  if (!serviceId) {
    console.error('拒绝会话失败: 未找到客服ID');
    return Promise.reject(new Error('客服信息不完整，请重新登录'));
  }
  
  console.log('当前客服ID:', serviceId);
  
  // 添加重试逻辑
  const maxRetries = 3;
  let retryCount = 0;
  
  const attemptReject = () => {
    retryCount++;
    console.log(`尝试拒绝会话 (${retryCount}/${maxRetries})...`);
    
    // 发送请求时确保serviceId作为请求体参数，reason作为URL参数
    return request.post(`/api/chat/session/${sessionId}/reject-assignment`, {
      serviceId: serviceId
    }, {
      params: { reason: rejectReason }
    })
    .then(response => {
      // 检查响应是否成功
      if (!response || response.success === false) {
        console.error(`拒绝会话响应错误: ${JSON.stringify(response)}`);
        throw new Error(response?.message || '拒绝会话失败');
      }
      
      console.log(`拒绝会话成功: ${JSON.stringify(response)}`);
      return response;
    })
    .catch(error => {
      console.error(`拒绝会话请求失败 (尝试 ${retryCount}/${maxRetries}):`, error);
      
      if (retryCount < maxRetries) {
        console.log(`拒绝会话失败，等待重试 (${retryCount}/${maxRetries})...`);
        // 等待1秒后重试
        return new Promise(resolve => {
          setTimeout(() => resolve(attemptReject()), 1000);
        });
      }
      
      // 提供更详细的错误信息
      throw new Error(error.message || '拒绝会话失败，请稍后重试');
    });
  };
  
  return attemptReject();
};

/**
 * 获取可用客服列表
 */
export function getAvailableServices() {
  return request.get('/api/chat/service/available');
}

/**
 * 手动分配会话
 */
export const assignSession = (sessionId, serviceId) => {
  return request.post(`/api/chat/session/${sessionId}/assign`, null, {
    params: { serviceId }
  });
};

/**
 * 获取会话统计
 * @param {string} startDate - 开始日期，格式：yyyy-MM-dd
 * @param {string} endDate - 结束日期，格式：yyyy-MM-dd
 */
export function getSessionStats(startDate, endDate) {
  return request.get('/api/chat/session/stats', {
    params: {
      startDate,
      endDate
    }
  });
}

/**
 * 清空聊天历史记录
 * @param {string} sessionId - 会话ID
 * @returns {Promise} 清空结果
 */
export function clearChatHistory(sessionId) {
  return request.delete(`/api/chat/session/${sessionId}/history`);
}

/**
 * 获取会话列表
 * @param {Object} params - 查询参数
 * @returns {Promise}
 */
export function getSessionList(params) {
  // 从缓存中获取用户信息
  const userInfo = uni.getStorageSync('userInfo');
  
  if (!userInfo || (!userInfo.id && !userInfo.userId)) {
    console.error('获取会话列表失败: 未找到用户ID');
    return Promise.reject(new Error('未登录或用户信息不完整'));
  }
  
  // 使用userId字段，如果不存在则尝试使用id字段
  const userId = userInfo.userId || userInfo.id;
  
  if(typeof params === 'object') {
    // 创建新的参数对象，包含userId
    const newParams = { 
      ...params,
      userId
    };
    
    console.log('获取会话列表，参数:', newParams);
    return request.get('/api/chat/sessions', { params: newParams });
  } else {
    console.log('获取会话列表，用户ID:', userId);
    return request.get('/api/chat/sessions', { 
      params: { userId } 
    });
  }
}

/**
 * 上传图片
 * @param {string} sessionId - 会话ID
 * @param {FormData} formData - 图片数据
 * @returns {Promise}
 */
export function uploadImage(sessionId, formData) {
    return request.post(`/api/chat/session/${sessionId}/upload`, formData, {
        headers: {
            'Content-Type': 'multipart/form-data'
        }
    });
}

/**
 * 提交评价
 * @param {string} sessionId - 会话ID
 * @param {number} rating - 评分(1-5)
 * @param {string} comment - 评价内容
 * @returns {Promise}
 */
export function submitEvaluation(sessionId, rating, comment) {
    console.log('提交评价，会话ID:', sessionId, '评分:', rating, '评价:', comment);
    return request.post(`/api/chat/session/${sessionId}/evaluate`, null, {
        params: {
            score: rating,
            evaluation: comment
        }
    }).catch(error => {
        console.error('提交评价失败:', error);
        throw new Error('提交评价失败: ' + (error.message || '未知错误'));
    });
}

/**
 * 获取客服列表
 * @returns {Promise}
 */
export function getServiceList() {
  return request.get('/api/chat/service/list');
}

/**
 * 获取客服详情
 * @param {string} serviceId - 客服ID
 * @returns {Promise}
 */
export function getServiceDetail(serviceId) {
    return request.get(`/api/chat/service/${serviceId}`);
}

/**
 * 获取客服统计数据
 * @param {Object} params - 查询参数
 * @returns {Promise}
 */
export function getServiceStatistics(params) {
    return request.get('/api/chat/service/statistics', { params });
}

/**
 * 分页查询会话
 */
export const getSessionPage = (params) => {
  return request.get('/api/chat/session', { params });
};

/**
 * 更新客服状态
 * @param {string} status - 客服状态 (ONLINE/BUSY/OFFLINE)
 */
export const updateServiceStatus = (status) => {
  return request.post('/api/chat/status', { status });
};

/**
 * 获取工作量统计
 */
export const getWorkloadStats = (startDate, endDate, serviceId) => {
  return request.get('/api/chat/session/workload', {
    params: { startDate, endDate, serviceId }
  });
};

/**
 * 获取满意度统计
 */
export const getSatisfactionStats = (startDate, endDate) => {
  return request.get('/api/chat/session/satisfaction', {
    params: { startDate, endDate }
  });
};

/**
 * 客服发送消息的专用方法，确保正确的消息格式
 * @param {string} sessionId - 会话ID
 * @param {string} content - 消息内容
 */
export const sendServiceMessage = async (sessionId, content) => {
  if (!sessionId) {
    console.error('发送消息失败: 会话ID为空');
    return Promise.reject(new Error('会话ID不能为空'));
  }
  
  if (!content) {
    console.error('发送消息失败: 消息内容为空');
    return Promise.reject(new Error('消息内容不能为空'));
  }
  
  console.log('客服发送消息, sessionId:', sessionId, 'content:', content);
  
  // 获取客服信息
  const userInfo = uni.getStorageSync('userInfo');
  let serviceId;
  
  if (userInfo?.serviceInfo?.id) {
    serviceId = userInfo.serviceInfo.id;
  } else {
    serviceId = userInfo?.userId || userInfo?.id;
  }
  
  if (!serviceId) {
    console.error('发送消息失败: 未找到客服ID');
    return Promise.reject(new Error('客服信息不完整，请重新登录'));
  }
  
  // 尝试通过WebSocket发送
  const ws = uni.getStorageSync('websocket');
  if (ws && ws.readyState === 1) {
    try {
      console.log('通过WebSocket发送客服消息');
      
      // 确保消息格式正确
      const message = {
        type: 'CHAT',
        sessionId: sessionId,
        senderId: serviceId,
        senderType: 'SERVICE',
        content: content,
        messageType: 'TEXT',
        timestamp: new Date().toISOString(),
        status: 'SENT'
      };
      
      // 保存最后一条消息到本地存储，用于错误时重发
      uni.setStorageSync('last_message_' + sessionId, {
        content: content,
        timestamp: new Date().toISOString()
      });
      
      await sendWebSocketMessage(message);
      
      return {
        success: true,
        message: 'WebSocket发送成功',
        data: message
      };
    } catch (wsError) {
      console.error('WebSocket发送客服消息失败，尝试HTTP发送:', wsError);
    }
  }
  
  // 如果WebSocket发送失败，使用HTTP API
  try {
    console.log('通过HTTP API发送客服消息');
    const response = await request.post(`/api/chat/service/send`, {
      sessionId: sessionId,
      content: content,
      serviceId: serviceId
    });
    
    console.log('HTTP API发送客服消息响应:', response);
    
    if (!response || response.success === false) {
      throw new Error(response?.message || '发送消息失败');
    }
    
    return response;
  } catch (error) {
    console.error('HTTP API发送客服消息失败:', error);
    
    // 如果后端接口已经更新，尝试使用旧版接口
    try {
      console.log('尝试通过旧版接口发送...');
      const legacyResponse = await request.post(`/api/chat/session/${sessionId}/message`, {
        content: content
      });
      
      console.log('旧版接口发送响应:', legacyResponse);
      
      if (!legacyResponse || legacyResponse.success === false) {
        throw new Error(legacyResponse?.message || '发送消息失败');
      }
      
      return legacyResponse;
    } catch (legacyError) {
      console.error('所有发送方式均失败:', legacyError);
      throw error; // 抛出原始错误
    }
  }
};

export default {
  checkSession,
  createSession,
  loadMessages,
  loadNewMessages,
  sendMessage,
  getServiceStats,
  getServiceSessions,
  getHistory,
  getSessions,
  createConversation,
  deleteConversation,
  evaluateSession,
  initiateTransfer,
  acceptTransfer,
  rejectTransfer,
  getPendingTransfers,
  getTransferHistory,
  cancelTransfer,
  getActiveSessions,
  getHistorySessions,
  getSessionDetail,
  getSessionMessages,
  endSession,
  searchSessions,
  getSessionsStats,
  connectWebSocket,
  acceptSession,
  rejectSession,
  transferSession,
  sendSessionMessage,
  getPendingSessions,
  acceptSessionAssignment,
  rejectSessionAssignment,
  getAvailableServices,
  assignSession,
  getSessionStats,
  clearChatHistory,
  getSessionList,
  uploadImage,
  submitEvaluation,
  getServiceList,
  getServiceDetail,
  getServiceStatistics,
  getSessionPage,
  updateServiceStatus,
  getWorkloadStats,
  getSatisfactionStats,
  sendServiceMessage
}; 